const Router = require('koa-router')
const User = require('../../models/User.js')
const bcrypt = require('bcrypt')
const gravatar = require("gravatar")
const jwt = require('jsonwebtoken')
const passport = require('koa-passport')
const nodeMailer = require('nodemailer')
const config = require('../../config/config')

const { find } = require('../../models/User.js')
// 引入register验证
const validateRegister = require('../../validator/register')
const validateLogin = require('../../validator/login')


const router = new Router()

// router.post('/test', ctx => {
//     ctx.cookies.set('mde', 'fb8e', {maxAge: 60*1000})
// })
// router.post('/test2', ctx => {
//     console.log(ctx.cookies.get('mde'))
// })


/**
 * @route post /api/user/verify
 * @desc 发送邮箱验证码
 * @access 接口是公开的
 */
router.post('/verify', async ctx => {
    // 设置邮箱配置
    
  let transporter = nodeMailer.createTransport({
    host: config.smtp.host, // 设置邮箱服务的主机，smtp.qq.com
    port: 587, // 对应的端口号
    secure: false,
    auth: { // 用户信息
      user: config.smtp.user,  // 发送者的邮箱
      pass: config.smtp.pass  // 发送者邮箱的凭证，此处用qq邮箱
    }
  })
  // 一些配置信息
  let options = {
    code: config.smtp.code(), // 从配置文件中取
    expire: config.smtp.expire(), // 从配置文件中取过期时间
    email: ctx.request.body.email,
    user: ctx.request.body.username
  }
//   ctx.cookies.set('code', options.code, {maxAge: 60*60*1000})
//   ctx.cookies.set('expire', options.expire, {maxAge: 60*60*1000})
  
    ctx.session.signInfo = {
        code: options.code,
        username: options.user,
        email: options.email,
        expire: options.expire
    }

  // 设置收件人信息
  let mailOptions = {
    from: `"认证邮件"<${config.smtp.user}>`, // 设置发件人名称
    to: options.email, // 发给谁
    subject:'注册账号', // 主题
    html:`您的邀请码是 ${options.code} ,请尽快完成验证！` // html模板
  }
  // 发送邮件
  await transporter.sendMail(mailOptions,(err,info) => {
    if(err) {
      return console.log('error')
    } else { // 发送成功
      // 存储到session
     //  这里面设置存储没有用
    
    }
  })
  ctx.body = {
    code: 0,
    msg: '验证码已发送，可能会有延时，有效期1分钟'
  }
})

/**
 * @route POST /api/user/register
 * @desc 注册接口地址
 */
router.post('/register', async ctx => {
    let postdata = ctx.request.body
    // 验证表单
    const {errors, isValid} = validateRegister(postdata)
    if (!isValid) {
        ctx.status = 400;
        ctx.body = errors;
        return;
    }
    // 先校验邮箱验证码，匹配成功查询邮箱是否注册
    const code = postdata.code
    // console.log(ctx.session.signInfo)
    if (code) {
        // 从session中查询code expire email
        const saveCode = ctx.session.signInfo.code
        const saveExpire = ctx.session.signInfo.expire
        // const saveCode = ctx.cookies.get('code')
        // const saveExpire = ctx.cookies.get('expire')
        if (code === saveCode) {
            if ((new Date().getTime() - saveExpire) > 0) {
                ctx.body = {
                    code: -1,
                    msg: '验证码已过期，请重新尝试'
                }
                return false
            } 
        } else {
            ctx.body = {
                code: -1,
                msg: '请填写正确的验证码'
            }
            return false;
        }
    } else {
        ctx.body = {
            code: -1,
            msg: '请填写验证码'
        }
        return false;
    }

    // 校验邮箱是否在数据库中
    const findResult = await User.find({"email":postdata.email})
    if (findResult.length > 0) {
        ctx.status = 404
        ctx.body = {msg: '邮箱已经被占用！'}
    } else {
        // 如果数据库中没有查到则创建
        const avatar = gravatar.url(postdata.email, {s: '200', r: 'pg', d: 'mm'});
        let newUser = new User({
            username: postdata.username,
            email: postdata.email,
            password: postdata.password,
            avatar
        })
        // 对密码进行加密
        const hash = bcrypt.hashSync(postdata.password, 10);
        newUser.password = hash;

        // bcrypt.genSalt(10, (err, salt) => {
            
        //         bcrypt.hash(postdata.password, salt, (err, hash) => {
        //             if (err) throw(err);
        //             newUser.password = hash;
        //         });
            
        // });
        
        // 保存到数据库中
        try {
            await newUser.save();
            ctx.body = {
                code: 0,
                msg: '注册成功'
            }
        } catch (error) {
            ctx.body = {
                code: -1,
                msg: '服务端错误'
            }
            return 
        }
    }
})

/**
 * @route post /api/user/login
 * @desc 登录接口地址
 * @access 接口是公开的
 */
router.post('/login',async ctx => {
    let data = ctx.request.body;
    // 验证表单
    const {errors, isValid} = validateLogin(data)
    if (!isValid) {
        ctx.status = 400;
        ctx.body = errors;
        return;
    }

    let findResult = await User.findOne({"email":data.email})
    // console.log(findResult)
    if (!findResult) {
        ctx.status = 404
        ctx.body = '邮箱不存在'
    } else {
        // 邮箱存在，验证密码
        const result = bcrypt.compareSync(data.password, findResult.password)
        // 生成token
        const payload = {
            id: findResult._id,
            username: findResult.username,
        }
        const token = jwt.sign(payload, "secret", {expiresIn: 3600})
        if (result) {
            ctx.status = 200;
            ctx.body = { success: true, token: "Bearer "+token }
        } else {
            ctx.status = 400;
            ctx.body = {msg: '密码错误'}
        }
    }
})

/**
 * @route get /api/user/info
 * @desc 获取用户信息地址
 * @access 接口是私有的，只能通过token获取
 */

router.get('/info', passport.authenticate('jwt', { session: false }), async ctx => {
    ctx.status = 200
    ctx.body = {
        id: ctx.state.user.id,
        name: ctx.state.user.username,
        email: ctx.state.user.email,
        avatar: ctx.state.user.avatar
    }
})


module.exports = router.routes()